﻿/* 
* Copyright (c) 2010, The University of Texas at Austin
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, 
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation and/or other materials 
* provided with the distribution.
*
* Neither the name of The University of Texas at Austin nor the names of its contributors may be 
* used to endorse or promote products derived from this software without specific prior written 
* permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Windows.Media;
using Bio.Views.Structure.Editor.Internal.Data;
using Bio.Views.Structure.Editor.Internal.Options;
using Bio.Views.Structure.Editor.Internal.Rendering;
using JulMar.Windows.Mvvm;

namespace Bio.Views.Structure.Editor.ViewModels
{
    public class BasePairVisualRenderingOptionsViewModel : SimpleViewModel
    {
        public string Label
        {
            get { return Data.Label; }
        }

        public List<NamedColor> ValidColors
        {
            get { return _validColors; }
            private set
            {
                _validColors = value;
                OnPropertyChanged("ValidColors");
            }
        }

        public List<string> ValidRenderingModes
        {
            get { return _validRenderingModes; }
            private set
            {
                _validRenderingModes = value;
                OnPropertyChanged("ValidRenderingModes");
            }
        }

        public Brush ConnectorStroke
        {
            get { return Data.Options.BasePairConnectorStroke; }
            set
            {
                Data.Options.BasePairConnectorStroke = value;
                OnPropertyChanged("ConnectorStroke");
            }
        }

        public Brush ConnectorFill
        {
            get { return Data.Options.BasePairConnectorFill; }
            set
            {
                Data.Options.BasePairConnectorFill = value;
                OnPropertyChanged("ConnectorFill");
            }
        }

        public bool ConnectorVisible
        {
            get { return Data.Options.BasePairConnectorIsVisible; }
            set
            {
                Data.Options.BasePairConnectorIsVisible = value;
                OnPropertyChanged("ConnectorVisible");
            }
        }

        public bool ConnectorFilled
        {
            get { return Data.Options.BasePairConnectorIsFilled; }
            set
            {
                Data.Options.BasePairConnectorIsFilled = value;
                OnPropertyChanged("ConnectorFilled");
            }
        }

        public double ConnectorSize
        {
            get { return Data.Options.BasePairConnectorSize; }
            set
            {
                if (value >= 0.0)
                {
                    Data.Options.BasePairConnectorSize = value;
                    OnPropertyChanged("ConnectorSize");
                }
            }
        }

        public double ConnectorStrokeThickness
        {
            get { return Data.Options.BasePairConnectorStrokeThickness; }
            set
            {
                if (value >= 0.0)
                {
                    Data.Options.BasePairConnectorStrokeThickness = value;
                    OnPropertyChanged("ConnectorStrokeThickness");
                }
            }
        }

        public string ConnectorRenderingMode
        {
            get { return Data.Options.BasePairConnectorRenderingStyle.ToString(); }
            set
            {
                BasePairConnectorRenderingMode val;
                if (Enum.TryParse<BasePairConnectorRenderingMode>(value, true, out val))
                {
                    Data.Options.BasePairConnectorRenderingStyle = val;
                    OnPropertyChanged("ConnectorRenderingMode");
                }
            }
        }

        public BasePairVisualRenderingOptionsViewModel(BasePairVisualRenderingOptionsData data)
        {
            Data = data;
            List<NamedColor> builtIn = new List<NamedColor>();
            PropertyInfo[] colorProperties = typeof(Colors).GetProperties();
            foreach (var propertyinfo in colorProperties)
            {
                Color color = (Color)ColorConverter.ConvertFromString(propertyinfo.Name);
                NamedColor ntColor = new NamedColor() { Color = color, Label = propertyinfo.Name };
                builtIn.Add(ntColor);
            }
            ValidColors = builtIn;
            List<string> renderingModes = new List<string>();
            foreach (var val in Enum.GetNames(typeof(BasePairConnectorRenderingMode)))
                renderingModes.Add(val);
            ValidRenderingModes = renderingModes;
        }

        private BasePairVisualRenderingOptionsData _data;
        private BasePairVisualRenderingOptionsData Data
        {
            get { return _data; }
            set
            {
                _data = value;
                OnPropertyChanged("Label", "ConnectorStroke", "ConnectorFill", "ConnectorVisible", "ConnectorFilled", "ConnectorSize", "ConnectorStrokeThickness", "ConnectorRenderingMode");
            }
        }

        private List<NamedColor> _validColors;
        private List<string> _validRenderingModes;
    }
}
